import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

class MyThreadPool{
    //1、描述一个任务，直接使用 Runnable，不需要额外创建类了。
    //2、使用一个数据结构来组织若干任务
    private BlockingQueue<Runnable> queue = new LinkedBlockingDeque();
    //3、利用一个静态内部类来描述一个线程，工作线程的功能就是从任务队列中去任务并执行。
    static class Worker extends Thread{
        // 当前线程池中，有若干个 Worker线程
        // 这些线程内部 都持有上述的任务队列
        BlockingQueue<Runnable> queue = null;
        public Worker(BlockingQueue<Runnable> queue){
            this.queue = queue;
        }
        @Override
        public void run() {
            // 先拿到上面的队列，才能谈下一步的获取任务
            while(true){
                try {
                    // 循环的去获取任务队列中的任务
                    Runnable runnable = queue.take();
                    // 获取到之后，就执行任务
                    runnable.run();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    // 4、 创建一个数据结构来组织若干个线程
    private List<Thread>  workers = new ArrayList<>();
    public MyThreadPool(int n){
        //在构造方法中，创建出若干个线程，放到上述的数组中
        for (int i = 0; i < n; i++) {
            Worker worker = new Worker(queue);// 调用带参的构造方法，参数为阻塞队列的对象
            worker.start();// 启动线程
            workers.add(worker);
        }
    }
    // 5、创建一个方法，能够允许程序员来放任务到线程池中
    public void submit(Runnable runnable){
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


public class Test26 {
    public static void main(String[] args) {
        // 创建一个 线程数目为10 的 线程池
        MyThreadPool pool = new MyThreadPool(10);
        // 让线程池中 注册100个任务
        for (int i = 0; i < 100; i++) {
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello threadPool");
                }
            });
        }
    }
}
